package com.xmtlxx.common.utils;

import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.commons.lang.NullArgumentException;
import org.apache.commons.lang3.time.DateFormatUtils;

import java.lang.management.ManagementFactory;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.util.*;

/**
 * 时间工具类
 *
 * @author xmtlxx
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {

    public static String YYYY = "yyyy";

    public static String YYYY_MM = "yyyy-MM";

    public static String YYYY_MM_DD = "yyyy-MM-dd";

    public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";

    public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

    private static String[] parsePatterns = {
        "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
        "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
        "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};

    /**
     * 获取当前Date型日期
     *
     * @return Date() 当前日期
     */
    public static Date getNowDate() {
        return new Date();
    }

    /**
     * 获取当前日期, 默认格式为yyyy-MM-dd
     *
     * @return String
     */
    public static String getDate() {
        return dateTimeNow(YYYY_MM_DD);
    }

    public static final String getTime() {
        return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
    }

    public static final String dateTimeNow() {
        return dateTimeNow(YYYYMMDDHHMMSS);
    }

    public static final String dateTimeNow(final String format) {
        return parseDateToStr(format, new Date());
    }

    public static final String dateTime(final Date date) {
        return parseDateToStr(YYYY_MM_DD, date);
    }

    public static final String parseDateToStr(final String format, final Date date) {
        return new SimpleDateFormat(format).format(date);
    }

    public static final Date dateTime(final String format, final String ts) {
        try {
            return new SimpleDateFormat(format).parse(ts);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 日期路径 即年/月/日 如2018/08/08
     */
    public static final String datePath() {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyy/MM/dd");
    }

    /**
     * 日期路径 即年/月/日 如20180808
     */
    public static final String dateTime() {
        Date now = new Date();
        return DateFormatUtils.format(now, "yyyyMMdd");
    }

    /**
     * 日期型字符串转化为日期 格式
     */
    public static Date parseDate(Object str) {
        if (str == null) {
            return null;
        }
        try {
            return parseDate(str.toString(), parsePatterns);
        } catch (ParseException e) {
            return null;
        }
    }

    /**
     * 获取服务器启动时间
     */
    public static Date getServerStartDate() {
        long time = ManagementFactory.getRuntimeMXBean().getStartTime();
        return new Date(time);
    }

    /**
     * 计算相差天数
     */
    public static int differentDaysByMillisecond(Date date1, Date date2)
    {
        return Math.abs((int) ((date2.getTime() - date1.getTime()) / (1000 * 3600 * 24)));
    }

    /**
     * 计算两个时间差
     */
    public static String getDatePoor(Date endDate, Date nowDate) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - nowDate.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return day + "天" + hour + "小时" + min + "分钟";
    }

    /**
     * 增加 LocalDateTime ==> Date
     */
    public static Date toDate(LocalDateTime temporalAccessor) {
        ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * 增加 LocalDate ==> Date
     */
    public static Date toDate(LocalDate temporalAccessor) {
        LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
        ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
        return Date.from(zdt.toInstant());
    }

    /**
     * 获取当前包含毫秒时间字符串
     *
     * @return 当前时间字符串 yyyyMMddHHmmssSSS
     */
    public static String getCurrentDateTime() {
        Date date = new Date();
        SimpleDateFormat sim = new SimpleDateFormat("yyyyMMddHHmmssSSS");
        String dateChar = sim.format(date);
        return dateChar;
    }

    public static Integer getNowAccountMonth() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.MONTH, -1);
        return cal.get(Calendar.YEAR)*100+cal.get(Calendar.MONTH)+1;
    }

    public static Integer getDateYear(Date data) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(data);
        return cal.get(Calendar.YEAR);
    }

    /**
     * 获取当前的账期月份.
     *
     * @return 账期月份
     *         <p>
     *         使用账期年份*100 + 账期月份
     *         </p>
     */
    public static Integer getNowYearMonth()
    {
        Calendar cal = Calendar.getInstance();
        return cal.get(Calendar.YEAR)*100+cal.get(Calendar.MONTH)+1;
    }

    /**
     * 校验指定的账期月份字符串是否有效，如果有效则转换成指定数值。
     *
     * <pre>
     * 账期月份字符串包含以下情况，则为无效
     * 1.日期在1993年之前
     * 2.账期月份跟当前年月一样，或是当前年月之后的
     * 3.年份在1993之前或是当前所在年份之后
     * 4.月份不是有效的月份日期（01~12）
     * </pre>
     *
     * @param yearMonth
     *            账期月份字符串，日期格式为yyyyMM
     * @return 如果账期字符串是有效的账期字符串，则计算其账期月份
     *         <p>
     *         使用账期年份*100 + 账期月份
     *         </p>
     */
    public static Integer getCheckYearMonth(String yearMonth)
    {
        try
        {
            if(StringUtils.isAllNumbric(yearMonth))
            {
                int num = Integer.parseInt(yearMonth);
                if(num<=199300)
                {
                    return null;
                }
                Calendar cal = Calendar.getInstance();
                int year = num/100;
                if(year<1993||year>cal.get(Calendar.YEAR))
                {
                    return null;
                }
                int month = num%100;
                if(month<1||month>12)
                {
                    return null;
                }
                if(year==cal.get(Calendar.YEAR)&&month>cal.get(Calendar.MONTH))
                {
                    return null;
                }
                return num;
            }
            else
            {
                return null;
            }
        }
        catch(Exception e)
        {
            return null;
        }
    }

    /**
     * 存放已经格式化的日期格式辅助类 主要是加快日期格式化的速度，减少日期格式化的对象创建
     */
    private static final Map<String, SimpleDateFormat> DateFormates = new HashMap<String, SimpleDateFormat>();

    /**
     * 获取当前时间的上一个月时间。 用于列表中按一个月内及一个月前的查询条件准备。
     *
     * @return 上一个月的时间
     */
    public static Date getDateBeforeAnMonth()
    {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MONTH, -1);
        return calendar.getTime();
    }

    /**
     * 获取指定时间与当前时间的标准化区别
     *
     * @param datetimeStr
     *            要分析的时间字符串(格式为:yyyy-MM-dd HH:mm)
     * @return 标准化的区别时间
     *
     *         <pre>
     * 年份不一样					显示完整时间[yyyy年MM月dd日 HH时mm分]
     * 前面都一样,月份不一样			显示完整时间[MM月dd日 HH时mm分]
     * 前面都一样,日期不一样			显示完整时间[dd日 HH时mm分]
     * 前面都一样,小时数不一样		显示完整时间[HH时mm分]
     * 前面都一样,分钟数不一样		显示完整时间[HH时mm分]
     * 前面都一样,秒数不一样			显示完整时间[0秒前]
     * 全部一样(除了毫秒数不一样)		显示[刚刚]
     * </pre>
     */
    public static String getShowDatetimeFormat(String datetimeStr)
    {
        try
        {
            return getShowDatetimeFormat(string2Date(datetimeStr, "yyyy-MM-dd HH:mm"));
        }
        catch(Exception e)
        {
            return datetimeStr;
        }
    }

    /**
     * 获取指定时间与当前时间的标准化区别
     *
     * @param date
     *            要分析的时间
     * @return 标准化的区别时间
     *
     *         <pre>
     * 年份不一样					显示完整时间[yyyy年MM月dd日 HH时mm分]
     * 前面都一样,月份不一样			显示完整时间[MM月dd日 HH时mm分]
     * 前面都一样,日期不一样			显示完整时间[dd日 HH时mm分]
     * 前面都一样,小时数不一样		显示完整时间[HH时mm分]
     * 前面都一样,分钟数不一样		显示完整时间[HH时mm分]
     * 前面都一样,秒数不一样			显示完整时间[0秒前]
     * 全部一样(除了毫秒数不一样)		显示[刚刚]
     * </pre>
     */
    public static String getShowDatetimeFormat(Date date)
    {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        Calendar now = Calendar.getInstance();
        if(cal.get(Calendar.YEAR)!=now.get(Calendar.YEAR))
        {
            return date2String(date, "yyyy年MM月dd日 HH时mm分");
        }
        else if(cal.get(Calendar.MONTH)!=now.get(Calendar.MONTH))
        {
            return date2String(date, "MM月dd日 HH时mm分");
        }
        else if(cal.get(Calendar.DAY_OF_MONTH)!=now.get(Calendar.DAY_OF_MONTH))
        {
            return date2String(date, "dd日 HH时mm分");
        }
        else if(cal.get(Calendar.HOUR_OF_DAY)!=now.get(Calendar.HOUR_OF_DAY))
        {
            return date2String(date, "HH时mm分");
        }
        else if(cal.get(Calendar.MINUTE)!=now.get(Calendar.MINUTE))
        {
            return date2String(date, "HH时mm分");
        }
        else if(cal.get(Calendar.SECOND)!=now.get(Calendar.SECOND))
        {
            return now.get(Calendar.SECOND)-cal.get(Calendar.SECOND)+"秒前";
        }
        return "刚刚";
    }
    public static String getShowDatetimeFormat2(Date date)
    {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        Calendar now = Calendar.getInstance();
        if(cal.get(Calendar.YEAR)!=now.get(Calendar.YEAR))
        {
            return date2String(date, "yyyy年MM月dd日 HH时mm分");
        }
        else if(cal.get(Calendar.MONTH)!=now.get(Calendar.MONTH))
        {
            return date2String(date, "MM月dd日 HH时mm分");
        }
        else if(cal.get(Calendar.DAY_OF_MONTH)!=now.get(Calendar.DAY_OF_MONTH))
        {
            return date2String(date, "dd日 HH时mm分");
        }
        else if(cal.get(Calendar.HOUR_OF_DAY)!=now.get(Calendar.HOUR_OF_DAY))
        {
            Integer hour = now.get(Calendar.HOUR_OF_DAY)- cal.get(Calendar.HOUR_OF_DAY);
            return hour+ "小时前";
//            return date2String(date, "HH时mm分");
        }
        else if(cal.get(Calendar.MINUTE)!=now.get(Calendar.MINUTE))
        {
            return now.get(Calendar.MINUTE) - cal.get(Calendar.MINUTE) +"分钟前";
//            return date2String(date, "HH时mm分");
        }
        else if(cal.get(Calendar.SECOND)!=now.get(Calendar.SECOND))
        {
            return now.get(Calendar.SECOND)-cal.get(Calendar.SECOND)+"秒前";
        }
        return "刚刚";
    }
    /**
     * 获取指定日期格式字符串的日期格式化辅助类
     *
     * @param pattern
     *            日期格式字符串
     * @return 日期格式化字符串
     */
    protected static SimpleDateFormat getDateFormat(String pattern)
    {
        if(pattern==null)
        {
            pattern = "yyyy-MM-dd HH:mm:ss";
        }
        synchronized(DateFormates)
        {
            if(DateFormates.containsKey(pattern))
            {
                return DateFormates.get(pattern);
            }
            else
            {
                SimpleDateFormat dateFormate = new SimpleDateFormat(pattern);
                DateFormates.put(pattern, dateFormate);
                return dateFormate;
            }
        }
    }

    /**
     * 将指定日期字符串按照指定格式格式化为日期
     *
     * @param date
     *            字符串 日期字符串
     * @param pattern
     *            日期格式字符串
     * @return 格式化后的日期. 如果日期字符串为Null或无法格式化则返回Null
     */
    public static Date string2Date(String date, String pattern)
    {
        if(date==null)
        {
            return null;
        }
        try
        {
            return getDateFormat(pattern).parse(date);
        }
        catch(ParseException e)
        {
            return null;
        }
    }

    /**
     * 将指定日期字符串按照格式[yyyy-MM-dd HH:mm:ss]格式化为日期
     *
     * @param date
     *            日期字符串
     * @return 格式化后的日期. 如果日期字符串为Null或无法格式化则返回Null
     */
    public static Date string2Date(String date)
    {
        if(date==null)
        {
            return null;
        }
        try
        {
            return getDateFormat(null).parse(date);
        }
        catch(ParseException e)
        {
            return null;
        }
    }

    /**
     * 将指定日期转换为指定的日期格式的日期字符串
     *
     * @param date
     *            要标准化的日期
     * @param pattern
     *            日期格式，如yyyy-MM-dd HH:mm:ss
     * @return 标准化后的日期字符串
     */
    public static String date2String(Date date, String pattern)
    {
        if(date==null)
        {
            return null;
        }
        return getDateFormat(pattern).format(date);
    }

    /**
     * 将日期转换为字符串,格式为:yyyy-MM-dd HH:mm:ss
     *
     * @param date
     *            要标准化的日期
     * @return 标准化后的日期字符串
     */
    public static String date2String(Date date)
    {
        if(date==null)
        {
            return null;
        }
        return getDateFormat(null).format(date);
    }

    /**
     * 将传入的日期向前（或向后）滚动|amount|月
     *
     * @param date
     *            要处理的日期
     * @param amount
     *            要调整的月份
     *
     *            <pre>
     * 正整数		向后调整指定月份
     * 负整数		向前调整指定月份
     * </pre>
     * @return 调整后的日期
     * @throws NullArgumentException
     *             如果日期参数为空，则抛出该意外
     */
    public static Date rollByMonth(Date date, int amount)
        throws NullArgumentException
    {
        if(date==null)
        {
            throw new NullArgumentException("参数[date]不能为空");
        }
        if(amount==0)
        {
            return date;
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MONTH, amount);
        return cal.getTime();
    }

    /**
     * 将传入的日期向前（或向后）滚动|amount|天
     *
     * @param date
     *            要处理的日期
     * @param amount
     *            要调整的天数
     *
     *            <pre>
     * 正整数		向后调整指定天数
     * 负整数		向前调整指定天数
     * </pre>
     * @return 调整后的日期
     * @throws NullArgumentException
     *             如果日期参数为空，则抛出该意外
     */
    public static Date rollByDay(Date date, int amount)
        throws NullArgumentException
    {
        if(date==null)
        {
            throw new NullArgumentException("参数[date]不能为空");
        }
        if(amount==0)
        {
            return date;
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.DAY_OF_YEAR, amount);
        return cal.getTime();
    }

    /*
     * 计算两个时间相差的月数
     */
    public static int getDiffer(Date begin, Date end)
        throws Exception
    {
        Calendar cal = Calendar.getInstance();
        cal.setTime(begin);
        int beginYear = cal.get(Calendar.YEAR);
        int beginMonth = cal.get(Calendar.MONTH);
        cal.setTime(end);
        int endYear = cal.get(Calendar.YEAR);
        int endMonth = cal.get(Calendar.MONTH);
        int difMonth = (endYear-beginYear)*12+(endMonth-beginMonth);

        return difMonth;
    }

    /**
     * 获取某天的最开始时间
     *
     * @param date
     * @return
     */
    public static Date getDateFirstSecond(Date date)
    {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取某天的最后时间
     *
     * @param date
     * @return
     */
    public static Date getDateLastSecond(Date date)
    {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.HOUR, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        return calendar.getTime();
    }

    /**
     * @param date1
     *            需要比较的时间 不能为空(null),需要正确的日期格式
     * @param date2
     *            被比较的时间 为空(null)则为当前时间
     * @param stype
     *            返回值类型 0为多少天，1为多少个月，2为多少年
     * @return
     */
    public static int compareDate(String date1, String date2, int stype)
    {
        int n = 0;
        String formatStyle = stype==1?"yyyy-MM":"yyyy-MM-dd";
        date2 = date2==null?getCurrentDate():date2;
        DateFormat df = new SimpleDateFormat(formatStyle);
        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();
        try
        {
            c1.setTime(df.parse(date1));
            c2.setTime(df.parse(date2));
        }
        catch(Exception e3)
        {
        }
        while(!c1.after(c2))
        {
            n++;
            if(stype==1)
            {
                c1.add(Calendar.MONTH, 1); // 比较月份，月份+1
            }
            else
            {
                c1.add(Calendar.DATE, 1); // 比较天数，日期+1
            }
        }
        n = n-1;
        if(stype==2)
        {
            n = (int)n/365;
        }
        return n;
    }

    /**
     * 得到当前日期
     *
     * @return
     */
    public static String getCurrentDate()
    {
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        SimpleDateFormat simple = new SimpleDateFormat("yyyy-MM-dd");
        return simple.format(date);
    }


    /*
     * 计算两个时间相差的天数数
     */
    public static int getDifferDay(Date begin, Date end) throws Exception {
        long start = begin.getTime();
        long to = end.getTime();
        if(start > to)
            return -1;

        long diff = to - start;
        Long d = new Long(diff / (24*60*60*1000));
        return d.intValue();
    }

    /**
     * 两个时间差，以秒计算
     *
     * @param time1
     * @param time2
     * @return
     */
    public static long getTimeSS(String time1, String time2)
    {
        try
        {
            return (string2Date(time2).getTime()-string2Date(time1).getTime())/1000;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return 0;
    }

    /**
     * @param mins
     * 				    秒
     * @return
     */
    public static String getTimeByMin(long mins){
        String result = "";
        if(mins != 0){
            long hour = mins / (60 * 60);
            long minute = (mins - hour * 60 * 60 ) / (60);
            long second = (mins - hour * 60 * 60 - minute * 60) ;
            if (second >= 60) {
                second = second % 60;
                minute += second / 60;
            }
            if (minute >= 60) {
                minute = minute % 60;
                hour += minute / 60;
            }
            String h = " ";
            String m = " ";
            String s = " ";
            if (hour < 10) {
                h = "0 " + String.valueOf(hour);
            } else {
                h = String.valueOf(hour);
            }
            if (minute < 10) {
                m = "0 " + String.valueOf(minute);
            } else {
                m = String.valueOf(minute);
            }
            if (second < 10) {
                s = "0 " + String.valueOf(second);
            } else {
                s = String.valueOf(second);
            }
            if(hour != 0){
                result +=hour + "小时";
            }
            if(minute != 0){
                result += minute + "分";
            }
            if(second != 0){
                result += second + "秒 ";
            }
        }else{
            result ="0小时0分0秒";
        }
        return result;
    }

    public static String secToTime(int time) {
        String timeStr = null;
        int hour = 0;
        int minute = 0;
        int second = 0;
        if (time <= 0)
            return "00:00";
        else {
            minute = time / 60;
            if (minute < 60) {
                second = time % 60;
                timeStr = unitFormat(minute) + ":" + unitFormat(second);
            } else {
                hour = minute / 60;
                if (hour > 99)
                    return "99:59:59";
                minute = minute % 60;
                second = time - hour * 3600 - minute * 60;
                timeStr = unitFormat(hour) + "时" + unitFormat(minute) + "分";
//                timeStr = unitFormat(hour) + "时" + unitFormat(minute) + "分" + unitFormat(second);
            }
        }
        return timeStr;
    }

    /**
     * 根据开始时间 截止时间 间隔类型 获取时间切片
     * @param start
     * @param end
     * @param type
     * @return
     */
    public static List<String> getTimeArrs(String start,String end,Short type){
        List<String> result = new ArrayList<String>();
        Integer mins = type == 0 ? 30 : 60;//间隔分钟数
        long timess = getTimeSS(start, end)/60;//得到间隔分钟数
        if(timess < 0 || timess < mins){
            return null;
        }
        long nums = timess/mins;//取整
        long lev = timess%mins;//取余
        if(lev > 0){
            nums = nums+1;
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(string2Date(start));
        String st = start;
        for(int i = 0;i<nums;i++){
            cal.add(Calendar.MINUTE, mins);
            String ed = DateUtils.date2String(cal.getTime());
            long flag = getTimeSS(ed, end);
            if(flag < 0){
                ed = end;
            }
            result.add(st+"/"+ed);
            st = ed;
        }
        return result;
    }

    public static String unitFormat(int i) {
        String retStr = null;
        if (i >= 0 && i < 10)
            retStr = "0" + Integer.toString(i);
        else
            retStr = "" + i;
        return retStr;
    }

    /**
     * 时间分割
     * 获取开始 结束时间
     * 1、先计算间隔分钟数===>得到A
     * 2、然后 用A/nums 得到 每次间隔分钟；
     * 3、根据算法 start+(index*A) 得到开始时间；
     * 4、根据算法 start+((index+1)*A) 得到结束时间；
     * @param start
     * @param end
     * @param nums
     * @param index
     * @return
     */
    public static String getStAndEdTime(Date start,Date end,Integer nums,Integer index){
        String result = "";
        long timess = (end.getTime() - start.getTime())/1000;
        long splits = timess/nums;
        Long st = index*splits;
        Long ed = (index+1)*splits;
        Calendar cal  = Calendar.getInstance();
        cal.setTime(start);
        cal.add(Calendar.SECOND, st.intValue());
        result = DateUtils.date2String(cal.getTime());
        cal.setTime(start);
        cal.add(Calendar.SECOND, ed.intValue());
        result = result + "#"+DateUtils.date2String(cal.getTime());
        return result;
    }

    public static String getWeekMonDay(String dateStr) throws ParseException {
        // 设定时间值
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = simpleDateFormat.parse(dateStr);
        // 转为calendar格式
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);

        // 如果是周日
        if (calendar.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
            calendar.add(Calendar.DAY_OF_YEAR,-1);
        }

        /**
         * calendar.get(Calendar.MONTH)+1  calendar中的月份以0开头
         * Calendar.DAY_OF_WEEK 当前日期是所在周的第几天（以周日为一周的第一天）
         * Calendar.DATE 当前日期是几号
         *  */

        // 获取当前日期是当周的第i天
        int i = calendar.get(Calendar.DAY_OF_WEEK) - 1;

        // 获取当前日期所在周的第一天
        calendar.add(Calendar.DATE , -i+1);
        return new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime())+" 00:00:00";
    }

    public static String getWeekSunDay(String dateStr) throws ParseException {
        // 设定时间值
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = simpleDateFormat.parse(dateStr);
        // 转为calendar格式
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);

        // 如果是周日
        if (calendar.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
            calendar.add(Calendar.DAY_OF_YEAR,-1);
        }

        /**
         * calendar.get(Calendar.MONTH)+1  calendar中的月份以0开头
         * Calendar.DAY_OF_WEEK 当前日期是所在周的第几天（以周日为一周的第一天）
         * Calendar.DATE 当前日期是几号
         *  */

        // 获取当前日期是当周的第i天
        int i = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        // 获取当前日期所在周的第一天
        calendar.add(Calendar.DATE , -i+1);
        // 获取当前日期所在周的最后一天
        calendar.add(Calendar.DATE, 6);

        return new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime()) +" 23:59:59";
    }


    public static void main(String[] args) {
        Date date = string2Date("2022-12-05 10:00:00");
        System.out.println(org.apache.commons.lang.time.DateFormatUtils.format(date, "yy/M"));
    }

}
